GermanWikipedia - /page/entry.mu

Micron Document

<!DOCTYPE html>

<title>Go (Programmiersprache)</title>

</head>

<h1 id="firstHeading" class="firstHeading mw-first-heading">Go (Programmiersprache)</h1>

</header>

</div>

<th colspan="2" class="hintergrundfarbe6" style="font-size:larger;">Go

</th></tr>

<tr>

</td></tr>

<tr>

<th colspan="2" class="hintergrundfarbe5" style="font-size:105%; text-align:center;">Basisdaten

</th></tr>

<tr>

<td><a href="Programmierparadigma" title="Programmierparadigma">Paradigmen</a>:

</td>

<td><a href="Nebenl%C3%A4ufigkeit" title="Nebenläufigkeit">nebenläufig</a>, <a href="Imperative_Programmierung" title="Imperative Programmierung">imperativ</a>, <a href="Strukturierte_Programmierung" title="Strukturierte Programmierung">strukturiert</a>, <a href="Modulare_Programmierung" title="Modulare Programmierung">modular</a>, <a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">objektorientiert</a>, <a href="Generische_Programmierung" title="Generische Programmierung">generisch</a>

</td></tr>

<tr>

<td>Erscheinungsjahr:

</td>

<td>2009; erste stabile Version 2012

</td></tr>

<tr>

<td>Designer:

</td>

<td><a href="Rob_Pike" title="Rob Pike">Rob Pike</a>, <a href="Ken_Thompson" title="Ken Thompson">Ken Thompson</a>, <a href="Robert_Griesemer" title="Robert Griesemer">Robert Griesemer</a>

</td></tr>

<tr>

<td>Entwickler:

</td>

<td><a href="Robert_Griesemer" title="Robert Griesemer">Robert Griesemer</a>, <a href="Rob_Pike" title="Rob Pike">Rob Pike</a>, <a href="Ken_Thompson" title="Ken Thompson">Ken Thompson</a> u. a.

</td></tr>

<tr>

<td>Aktuelle <a href="Version_(Software)" title="Version (Software)">Version</a>

</td>

<td class="wikidata-content" style="white-space:nowrap;">1.25.5<a href="#cite_note-_9774563ad02d3acd-1">[1]</a> (2. Dezember 2025)

</td></tr>

<tr>

<td><a href="Typisierung_(Informatik)" title="Typisierung (Informatik)">Typisierung</a>:

</td>

<td><a href="Starke_Typisierung" title="Starke Typisierung">stark</a>, <a href="Statische_Typisierung" title="Statische Typisierung">statisch</a>

</td></tr>

<tr>

<td>Wichtige <a href="Implementierung" title="Implementierung">Implementierungen</a>:

</td>

<td>Gc, gccgo

</td></tr>

<tr>

<td>Beeinflusst von:

</td>

<td><a href="C_(Programmiersprache)" title="C (Programmiersprache)">C</a>, <a href="Newsqueak" title="Newsqueak">Newsqueak</a>, <a href="Alef_(Programmiersprache)" title="Alef (Programmiersprache)">Alef</a>, <a href="Limbo_(Programmiersprache)" title="Limbo (Programmiersprache)">Limbo</a>, <a href="Oberon_(Programmiersprache)" title="Oberon (Programmiersprache)">Oberon</a>

</td></tr>

<tr>

<td><a href="Betriebssystem" title="Betriebssystem">Betriebssystem</a>:

</td>

<td><a href="Linux" title="Linux">Linux</a>, <a href="MacOS" title="MacOS">macOS</a>, <a href="FreeBSD" title="FreeBSD">FreeBSD</a>, <a href="Microsoft_Windows" title="Microsoft Windows">Windows</a>, <a href="Google_Fuchsia" title="Google Fuchsia">Fuchsia</a>, Experimentell: <a href="DragonFly_BSD" title="DragonFly BSD">DragonFly BSD</a>, <a href="Plan_9_(Betriebssystem)" title="Plan 9 (Betriebssystem)">Plan 9</a>, <a href="Solaris_(Betriebssystem)" title="Solaris (Betriebssystem)">Solaris</a>, <a href="Z/OS" title="Z/OS">z/OS</a>

</td></tr>

<tr>

<td><a href="Lizenz" title="Lizenz">Lizenz</a>:

</td>

<td><a href="BSD-Lizenz" title="BSD-Lizenz">BSD-Lizenz</a>

</td></tr>

<tr>

</td></tr></tbody></table>

Go (auch Golang) ist eine <a href="Kompilierung" class="mw-redirect" title="Kompilierung">kompilierbare</a> <a href="Programmiersprache" title="Programmiersprache">Programmiersprache</a>, die <a href="Nebenl%C3%A4ufigkeit" title="Nebenläufigkeit">Nebenläufigkeit</a> und <a href="Garbage_Collection" title="Garbage Collection">automatische Speicherbereinigung</a> unterstützt. Entwickelt wurde Go von Mitarbeitern des Unternehmens <a href="Google_Inc." class="mw-redirect" title="Google Inc.">Google Inc.</a><a href="#cite_note-2">[2]</a> Die Entwürfe stammen von <a href="Robert_Griesemer" title="Robert Griesemer">Robert Griesemer</a>, <a href="Rob_Pike" title="Rob Pike">Rob Pike</a> und <a href="Ken_Thompson" title="Ken Thompson">Ken Thompson</a>.

<div class="mw-heading mw-heading2"><h2 id="Überblick">Überblick</h2></div>

Go wurde von Google entwickelt, um Problemen, die C, C++, Java und Co. mit sich brachten, zu begegnen. Insbesondere Probleme im Hinblick auf <a href="Skalierbarkeit" title="Skalierbarkeit">skalierbare</a> <a href="Netzwerkdienst" title="Netzwerkdienst">Netzwerkdienste</a>, <a href="Rechnerverbund" title="Rechnerverbund">Cluster</a>- und <a href="Cloud_Computing" title="Cloud Computing">Cloud Computing</a> haben das Team dazu geführt, Go zu entwickeln.<a href="#cite_note-3">[3]</a> Vor allem hat Go viel weniger <a href="Schl%C3%BCsselwort_(Programmierung)" title="Schlüsselwort (Programmierung)">Schlüsselwörter</a> als die Sprachen aus der C-Familie. Zudem sollte Go eins lösen: die Compiler-Ineffizienz in der C-Familie. Wichtige Ziele bei der Entwicklung waren unter anderem die Unterstützung von Nebenläufigkeit mit nativen Sprachelementen und die Erleichterung der Softwareentwicklung mit großen Entwicklerteams und großen <a href="Codebasis" title="Codebasis">Codebasen</a>.<a href="#cite_note-4">[4]</a> Go besitzt einen eigenen <a href="Garbage_Collector" class="mw-redirect" title="Garbage Collector">Garbage Collector</a>, erlaubt die Verwendung von <a href="Zeiger_(Informatik)" title="Zeiger (Informatik)">Zeigern</a>, verzichtet jedoch auf <a href="Zeigerarithmetik" class="mw-redirect" title="Zeigerarithmetik">Zeigerarithmetik</a>.<a href="#cite_note-5">[5]</a> Go ist eine kompilierte Sprache, bei der Wert auf eine hohe Übersetzungsgeschwindigkeit gelegt wurde.

Go orientiert sich syntaktisch an der Programmiersprache <a href="C_(Programmiersprache)" title="C (Programmiersprache)">C</a> mit einigem Einfluss aus der <a href="Niklaus_Wirth" title="Niklaus Wirth">Wirthschen</a> Sprachfamilie (<a href="Pascal_(Programmiersprache)" title="Pascal (Programmiersprache)">Pascal</a>, <a href="Modula-2" title="Modula-2">Modula</a> und insbesondere <a href="Oberon_(Programmiersprache)" title="Oberon (Programmiersprache)">Oberon</a>). Die Unterstützung für Nebenläufigkeit wurde nach Vorbild der von <a href="Tony_Hoare" title="Tony Hoare">Tony Hoare</a> eingeführten <a href="Communicating_Sequential_Processes" title="Communicating Sequential Processes">Communicating Sequential Processes</a> (CSP) gestaltet und steht in Tradition der Programmiersprachen <a href="Newsqueak" title="Newsqueak">Newsqueak</a>, <a href="Alef_(Programmiersprache)" title="Alef (Programmiersprache)">Alef</a> und <a href="Limbo_(Programmiersprache)" title="Limbo (Programmiersprache)">Limbo</a>.<a href="#cite_note-6">[6]</a>

<div class="mw-heading mw-heading2"><h2 id="Merkmale_und_Sprachmittel">Merkmale und Sprachmittel</h2></div>

Go bietet <a href="Closure_(Funktion)" title="Closure (Funktion)">Closures</a> und <a href="Reflexion_(Programmierung)" title="Reflexion (Programmierung)">Reflexion</a><a href="#cite_note-7">[7]</a> sowie <a href="Typsicherheit" title="Typsicherheit">Typsicherheit</a> und eine automatische Speicherbereinigung.

<a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">Objektorientierung</a> unterstützt Go durch <a href="Schnittstelle_(Objektorientierung)" title="Schnittstelle (Objektorientierung)">Interfaces</a> und <a href="Mixin" title="Mixin">Mixins</a>. Auf <a href="Klasse_(Objektorientierung)" title="Klasse (Objektorientierung)">Klassen</a> und <a href="Vererbung_(Programmierung)" title="Vererbung (Programmierung)">Vererbung</a> von Klassen wird bewusst verzichtet. Außerdem ist es möglich, den <a href="Quelltext" title="Quelltext">Quellcode</a> wie bei <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a> durch Pakete zu modularisieren.

Nebenläufigkeit wird durch <a href="Communicating_Sequential_Processes" title="Communicating Sequential Processes">Communicating Sequential Processes</a> realisiert, die Goroutinen genannt werden und über Kanäle (Channels) miteinander kommunizieren können. <a href="Generischer_Typ" title="Generischer Typ">Generische Typen</a> wurden in Version 1.18 eingeführt.<a href="#cite_note-8">[8]</a>

<a href="Unicode" title="Unicode">Unicode</a> wird in Form von <a href="UTF-8" title="UTF-8">UTF-8</a> unterstützt, sowohl für <a href="Zeichenkette" title="Zeichenkette">Strings</a> als auch für Variablen<a href="Bezeichner" title="Bezeichner">bezeichner</a> im Quelltext (allerdings nur Unicode-Buchstaben und -Ziffern), <code>Δt = t2 - t1</code> ist also möglich.<a href="#cite_note-9">[9]</a>

<div class="mw-heading mw-heading2"><h2 id="Syntax">Syntax</h2></div>

Die <a href="Syntax" title="Syntax">Syntax</a> von Go orientiert sich im Wesentlichen an der Syntax der Programmiersprache <a href="C_(Programmiersprache)" title="C (Programmiersprache)">C</a>, weicht davon aber an einigen Stellen ab. So kann beispielsweise auf den Abschluss von <a href="Anweisung_(Programmierung)" title="Anweisung (Programmierung)">Anweisungen</a> durch ein <a href="Semikolon" title="Semikolon">Semikolon</a> verzichtet werden. Datentypen werden bei <a href="Deklaration_(Programmierung)" title="Deklaration (Programmierung)">Deklarationen</a> hinter den Bezeichner geschrieben statt davor, um die Deklaration von Funktionstypen zu vereinfachen.<a href="#cite_note-10">[10]</a> Code-Blöcke werden mit <a href="Klammer_(Zeichen)#Geschweifte/geschwungene_Klammern_(Akkoladen)" title="Klammer (Zeichen)">geschweiften Klammern</a> abgegrenzt. Neben dem einfachen <a href="Gleichheitszeichen" title="Gleichheitszeichen">Gleichheitszeichen</a> als <a href="Zuweisung" title="Zuweisung">Zuweisungsoperator</a> gibt es zusätzlich den Operator <code>:=</code>, der Deklaration mit <a href="Typinferenz" title="Typinferenz">Typinferenz</a> und Zuweisung kombiniert. Die Sprache umfasst mit 25 <a href="Schl%C3%BCsselwort_(Programmierung)" title="Schlüsselwort (Programmierung)">Schlüsselwörtern</a> weniger Schlüsselwörter als <a href="Varianten_der_Programmiersprache_C" title="Varianten der Programmiersprache C">ANSI C</a>.

Kommentare werden wie in C oder C++ mit Schrägstrichen markiert; <code>/*</code> bis <code>*/</code> bezeichnet einen <a href="Kommentar_(Programmierung)" title="Kommentar (Programmierung)">Kommentar</a>, der auch mehrere Zeilen enthalten kann, <code>//</code> leitet einen Kommentar bis zum Ende der Zeile ein.

Jede Quelldatei gehört genau einem Paket an, das am Anfang der Datei mit der <code>package</code>-Anweisung angegeben wird.

Das Schlüsselwort für <a href="Funktion_(Programmierung)" title="Funktion (Programmierung)">Funktionen</a> lautet <code>func</code>, die Funktion <code>main</code> in dem „main“-Paket ist der <a href="Einsprungpunkt" title="Einsprungpunkt">Einsprungpunkt</a> des Go-Programms. Funktionen können mehrere Werte zurückgeben. Es ist üblich, als letzten <a href="Return_Code" title="Return Code">Rückgabewert</a> den Status über den Erfolg oder Misserfolg des Funktionsaufrufs zu übermitteln und sogleich mit einer <a href="Bedingte_Anweisung_und_Verzweigung" title="Bedingte Anweisung und Verzweigung">bedingten</a> <a href="Kontrollstruktur" title="Kontrollstruktur">Kontrollstruktur</a> zu überprüfen.

Jede Variable hat einen definierten Typ. Jede Variable, mit Ausnahme des „Blank identifier“ <code>_</code>, muss verwendet werden. Der „Blank identifier“ ignoriert eine Zuweisung, er ist ein anonymer <a href="Wildcard_(Informatik)" title="Wildcard (Informatik)">Platzhalter</a>.

Die Prüfung einer Bedingung in einer Kontrollstruktur wie <code>if</code>, <code>for</code> oder <code>switch</code> wird anders als bei anderen Sprachen nicht von Klammern umschlossen.

<div class="mw-heading mw-heading2"><h2 id="Einfache_Beispiele">Einfache Beispiele</h2></div>

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>package main

import "fmt"

func main() {

fmt.Println("Hallo Welt")

}

</pre></div>

Das obige <a href="Hallo-Welt-Programm" title="Hallo-Welt-Programm">Hallo-Welt-Programm</a> gibt am Ausgabemedium den String <code>Hallo Welt</code> aus.

Ein weiteres Beispiel berechnet die <a href="Kreiszahl" title="Kreiszahl">Kreiszahl</a> Pi näherungsweise über die <a href="Leibniz-Reihe" title="Leibniz-Reihe">Leibniz-Reihe</a>.

Für die Berechnung werden nichtsequentielle Go-Routinen und ein Kanal verwendet:

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>package main

import (

"fmt"

"math"

)

func main() {

fmt.Println(calcpi(5000))

}

// calcpi startet n Goroutinen, um eine

// Näherung von Pi zu berechnen.

func calcpi(n int) float64 {

ch := make(chan float64, n)

for k := 0; k < n; k++ {

// alle n Werte nichtsequentiell berechnen

go calcsubterm(ch, float64(k))

}

// das Ergebnis mit Null initialisieren

f := float64(0.0)

// alle n Werte addieren

f += <-ch

}

return f*4 //Die Leibniz-Reihe berechnet Pi/4

}

// berechnet das k-Element der Leibniz-Reihe

func calcsubterm(ch chan<- float64, k float64) {

ch <- math.Pow(-1, k) / (2*k + 1)

}

</pre></div>

Die einzelnen <a href="Summand" class="mw-redirect" title="Summand">Summanden</a> der <a href="Reihe_(Mathematik)" title="Reihe (Mathematik)">mathematischen Reihe</a> werden nichtsequentiell ausgeführt und schreiben ihre Ergebnisse jeweils in den Kanal <code>ch</code>. Gleichzeitig werden die Werte aus dem Kanal zu einem Gesamtergebnis addiert. Am <a href="Ausgabeger%C3%A4t" title="Ausgabegerät">Ausgabegerät</a> erscheint die Ziffernfolge <code>3.141392653591793</code>.<a href="#cite_note-11">[11]</a> Die Abweichung zur eigentlichen Kreiszahl ab der vierten Nachkommastelle ist vor allem auf die langsame Konvergenz der <a href="Leibniz-Reihe" title="Leibniz-Reihe">Leibniz-Reihe</a> zurückzuführen.

<div class="mw-heading mw-heading2"><h2 id="Typkonvertierung">Typkonvertierung</h2></div>

Anders als bei der Sprache C müssen Typen immer konvertiert werden. Es ist zum Beispiel nicht möglich, einen Wert vom Typ <a href="Integer_(Datentyp)" title="Integer (Datentyp)">Integer</a> in einer Variable vom Typ <a href="Gleitkommazahl" title="Gleitkommazahl">Float</a> zu speichern, ohne den Wert vorher zu konvertieren. Im folgenden Beispiel wird eine Variable vom Typ Integer deklariert und der Wert dieser Variable einer anderen Variable vom Typ Float zugewiesen. Man beachte, dass zwischen <code>int</code> und <code>uint</code> unterschieden wird. 8-<a href="Bit" title="Bit">Bit</a>-„Unsigned Integer“ <code>uint8</code> umfassen einen Bereich von (0 … 255) während <code>int8</code> einen Bereich von (−128 … 127) umfassen. Diese Vorgehensweise der strikten Typisierung ist sehr sinnvoll, da schwer zu findende <a href="Programmfehler" title="Programmfehler">Programmierfehler</a> so leichter erkannt werden können.

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>var i int = 100

var f float64 = float64(i)

var u uint = uint(f)

</pre></div>

Sofern bei der Deklaration direkt ein Wert zugewiesen wird, ist die explizite Nennung des Typs optional. Der Compiler ermittelt ihn anhand des Wertes oder der angegebenen Typenkonverterfunktionen. Auf Paketebene muss jede Anweisung mit einem Schlüsselwort beginnen, deshalb kann die folgende Kurzform nur innerhalb von Funktionen verwendet werden:

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>i := 100

f := float64(i)

u := uint(f)

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Zeiger">Zeiger</h2></div>

Im Gegensatz zu vielen Hochsprachen wie Java arbeitet die Programmiersprache Go mit Zeigern. Ein Zeiger (<a href="Englische_Sprache" title="Englische Sprache">englisch</a> pointer) enthält als Wert die <a href="Speicheradresse" title="Speicheradresse">Adresse eines Speicherbereichs</a>. Bestimmte Aufgaben können ohne Zeiger nicht programmiert werden. Dazu gehört die Übergabe von Werten an Funktionen (<a href="Referenzparameter" title="Referenzparameter">Call by reference</a>). Im folgenden Beispiel wird eine Variable vom Typ Integer mit dem Namen „n“ und dem Wert 100 initialisiert. Anschließend wird die Speicheradresse, also die Adresse im Speicher des Computers ausgegeben. Die Adresse der Variable „n“ wird also mit <code>&n</code> abgerufen. Die Syntax der Zeiger erinnert stark an die Sprache C.

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>var n int = 100

fmt.Println("Die Adresse der Variable:", &n)

// Beispiel-Ausgabe: 0xc000018030

</pre></div>

Im nächsten Beispiel wird wieder eine Variable vom Typ Integer mit dem Namen „n“ und dem Wert 100 initialisiert. Dann wird eine Pointer-Variable vom Typ Integer-Zeiger deklariert. Der Typ einer Zeiger-Variable wird durch einen führenden <a href="Sternchen_(Schriftzeichen)" title="Sternchen (Schriftzeichen)">Asterisk</a> (<code>*</code>) vor dem <a href="Variablentyp" class="mw-redirect" title="Variablentyp">Variablentyp</a> deklariert. Aus <code>int</code> wird <code>*int</code>. Anschließend wird die Speicheradresse der Variable „n“ als Wert der Zeiger-Variable „p“ deklariert. Daraufhin wird jene Adresse des Speichers ausgegeben, die von der Variable „n“ belegt wurde. Zuletzt wird jener Wert ausgegeben, der sich in der Speicheradresse befindet. Der Wert einer Speicherstelle, der in der Zeiger-Variable „p“ deklariert ist, kann mit <code>*p</code> ermittelt werden.

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>var n int = 100

var p *int = &n

// Gibt eine Speicheradresse aus, z.B. 0xc000018030

fmt.Println("Adresse gespeichert in der Zeiger-Variable p:", p)

// Gibt den Wert an, der in der Speicheradresse steht: 100

fmt.Println("Wert der Speicheradresse gespeichert in p:", *p)

</pre></div>

Eine Zeiger-Adresse ohne gespeicherten Zeiger wird „nil pointer“ genannt. Man kann einfach abfragen, ob eine Zeigeradresse eine Speicheradresse als Inhalt hat oder nicht.

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>if p != nil {

// Wenn zutreffend: Zeiger-Variable speichert einen Zeiger auf einen Speicherbereich

}

if p == nil {

// Wenn zutreffend: Zeiger-Variable speichert keinen Zeiger auf einen Speicherbereich

}

</pre></div>

Im letzten Beispiel soll die Verwendung beim Aufruf einer Funktion dargestellt werden. Zuerst werden zwei Variablen vom Typ Integer deklariert. Der Inhalt dieser zwei Variablen soll getauscht werden.

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>package main

import "fmt"

func main() {

a := 10

b := 50

// Anzeige vor dem Tausch

fmt.Println("Wert der Variable a:", a)

fmt.Println("Wert der Variable b:", b)

// Aufruf der Funktion tauschen

tauschen(&a, &b)

// Anzeige des Tausches

fmt.Println("Wert der Variable b:", b)

}

// Funktion tauschen

func tauschen(a, b *int) {

tmp := *a

*a = *b

*b = tmp

}

</pre></div>

Man kann also grob zusammenfassen, dass <code>&</code> die Speicheradresse einer Variable ermittelt, während <code>*</code> den gespeicherten Wert einer Speicheradresse ermittelt.<a href="#cite_note-12">[12]</a>

<div class="mw-heading mw-heading2"><h2 id="Objektorientierung">Objektorientierung</h2></div>

Go unterstützt objektorientierte Programmierung, sie ist jedoch nicht <a href="Klasse_(Objektorientierung)" title="Klasse (Objektorientierung)">klassenbasiert</a>. Datentypen können in Go <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methoden</a> besitzen. <a href="Polymorphie_(Programmierung)" title="Polymorphie (Programmierung)">Polymorphie</a> wird über Interfaces (<a href="Schnittstelle" title="Schnittstelle">Schnittstellen</a>) erreicht, über die Methodenaufrufe zur Laufzeit an die konkrete Implementierung gebunden werden (<a href="Dynamische_Bindung" title="Dynamische Bindung">Dynamische Bindung</a>). Für einen Datentyp muss nicht explizit deklariert werden, dass er ein bestimmtes Interface erfüllt. Diese Beziehung wird stattdessen implizit beim Kompilieren ermittelt, um lose <a href="Kopplung_(Softwareentwicklung)" title="Kopplung (Softwareentwicklung)">Kopplung</a> zu erreichen.

Statt <a href="Vererbung_(Programmierung)" title="Vererbung (Programmierung)">Vererbung</a> und Typ-Hierarchien kommt in Go Komposition zum Einsatz. Hierfür unterstützt Go eine Form von Mixins, die in Go embedding („Einbettung“) genannt wird: Eine <a href="Datenstruktur" title="Datenstruktur">Datenstruktur</a> kann beliebig viele andere Datentypen einbetten, sodass sie deren Methoden und Datenfelder erhält.

Beispiel zu Typen, Interfaces und Mixins:

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>package main

import "fmt"

// Definieren zweier Typen

type User struct {

Name string

}

type Admin struct {

User // Admin bettet zudem den Typ 'User' ein

Email string

}

// Ein Interface mit der Methode 'Notify()'

type Notifier interface {

Notify()

}

// User und Admin implementieren das Interface 'Notifier', indem sie jeweils eine

// entsprechende 'Notify()'-Methode haben. Eine vorherige Deklaration zur Implementierung

// ist nicht notwendig.

func (u User) Notify() {

fmt.Printf("User: Sending user email to %s\n", u.Name)

}

func (a Admin) Notify() {

fmt.Printf("Admin: Sending admin email to %s. The email address is %q.\n",

a.Name, // Verwenden des eingebetteten Feldes 'Name' vom User

a.Email)

}

func main() {

// Einen User und einen Admin erstellen

user := User{

Name: "john smith",

}

admin := Admin{

User: user,

Email: "john@example.com",

}

// Eine Variable vom Interfacetyp anlegen

var n Notifier

// Die implementierte Notify-Methode aufrufen

// Die Methode wird über die Interfacevariable aufgerufen

// Mittels dynamischer Bindung wird die Methode am richtigen Typ aufgerufen

n = user

n.Notify()

n = admin

n.Notify()

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Nebenläufigkeit">Nebenläufigkeit</h2></div>

Zur Unterstützung der nebenläufigen Programmierung in Go wird das Konzept der Kanäle (channels) genutzt, das eine relativ stark abstrahierte Möglichkeit der <a href="Synchrone_Kommunikation" title="Synchrone Kommunikation">synchronen</a> oder <a href="Asynchrone_Kommunikation" title="Asynchrone Kommunikation">asynchronen Kommunikation</a> zwischen Go-Routinen bietet. Ein Kanal ist dabei ein Speicherbereich, der durch <a href="Semaphor_(Informatik)" title="Semaphor (Informatik)">Semaphore</a> abgesichert ist und eine <a href="Warteschlange_(Datenstruktur)" title="Warteschlange (Datenstruktur)">Warteschlange</a> (buffered/asynchronous channel) oder lediglich eine Schnittstelle (unbuffered/synchronous channel) zur Verfügung stellt.<a href="#cite_note-13">[13]</a> Über einen Kanal lassen sich dabei nur Daten eines festen Typs übertragen. Hierbei ist jedoch keinerlei Begrenzung hinsichtlich des Typs gegeben, auch Channels für Channels sind denkbar.<a href="#cite_note-14">[14]</a>

Ein Kanal wird durch den Aufruf <code style="white-space:nowrap">make(chan typ)</code> (synchron) bzw. <code style="white-space:nowrap">make(chan typ, größe)</code> (asynchron, wenn größe > 0) erstellt. Anschließend können Go-Routinen in den Channel schreiben, von ihm lesen und ihn schließen.

Bei synchronen Kanälen blockiert ein Lesezugriff, bis eine andere Go-Routine in den Channel schreibt, bzw. der Schreibzugriff, bis eine andere Routine liest.

Bei asynchronen Kanälen tritt ein solches Verhalten nur auf, wenn der zu lesende Channel leer bzw. der zu schreibende Channel voll ist.

Es gibt in Go keine Beschränkung hinsichtlich der Anzahl an Go-Routinen, die einen Channel lesen und schreiben.

Trotz der ausgefeilten Synchronisationsmechanismen kann bei der Benutzung von Channels ein <a href="Deadlock_(Informatik)" title="Deadlock (Informatik)">Deadlock</a> auftreten, der die Go-Laufzeitumgebung veranlasst, das Programm zu beenden.

Eine Go-Routine kann über das <code>select</code>-Konstrukt auf mehreren Channels gleichzeitig lauschen, bzw. versuchen, in mehrere Channels zu schreiben, wobei dasjenige <code>case</code>-Statement ausgeführt wird, das zuerst nicht mehr blockiert, oder es wird im Fall mehrerer Optionen eine <a href="Pseudozufall" title="Pseudozufall">pseudozufällige</a> Wahl getroffen.

Daten werden mit <code style="white-space:nowrap">kanal <- Wert</code> in einen Kanal geschrieben und mit <code style="white-space:nowrap">variable = <-kanal</code> gelesen, wobei beim Lesen die Variablenzuweisung wegfallen kann. Das Lauschen auf einem Channel kann auch mit dem <code>for</code>-Konstrukt automatisiert werden, wobei die <a href="For-Schleife" title="For-Schleife">Schleife</a> verlassen wird, sobald der Channel geschlossen ist.

Beispiel:

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>package main

import "fmt"

func zehnMal(kanal chan string) {

// Argument empfangen

sag := <-kanal

// Zehnmal zurückschreiben

for i := 0; i < 10; i++ {

kanal <- sag

}

// Kanal schließen

close(kanal)

}

func main() {

// synchronen Kanal öffnen

kanal := make(chan string) // oder make(chan string, 0)

// Starten der parallelen Go-Routine „zehnMal()“

go zehnMal(kanal)

// Senden eines Strings

kanal <- "Hallo"

// Empfangen der Strings, bis der Channel geschlossen wird

for s := range kanal {

fmt.Println(s)

}

fmt.Println("Fertig!")

}

</pre></div>

Im Beispiel ruft <code>main()</code> die Go-Routine <code>zehnMal()</code> auf, die einen empfangenen String zehnmal über den gleichen Kanal zurückgibt und ihn danach schließt. Durch den synchronen Kanal warten die beiden Go-Routinen aufeinander, sodass <code>main()</code> erst in die <code>for</code>-Schleife eintritt, wenn <code>zehnMal()</code> den String empfangen hat. Wäre der Kanal nicht synchron, könnte ein Deadlock auftreten, wenn <code>main()</code> die geschriebene Variable sofort wieder liest (und sie dabei aus dem Puffer entfernt) und <code>zehnMal()</code> dadurch vergeblich auf sein Argument wartet. Wichtig ist auch, dass <code>zehnMal()</code> nach dem Schreiben der Strings den Kanal schließt, da <code>main()</code> sonst die Schleife nicht verlassen kann.

<div class="mw-heading mw-heading2"><h2 id="Implementierungen">Implementierungen</h2></div>

Es gibt mindestens zwei <a href="Compiler" title="Compiler">Compiler</a> für Go, die auf <a href="Linux" title="Linux">Linux</a>, <a href="MacOS" title="MacOS">macOS</a>, <a href="Microsoft_Windows" title="Microsoft Windows">Windows</a> und <a href="FreeBSD" title="FreeBSD">FreeBSD</a> betrieben werden können und die Go-1-Spezifikation vollständig implementieren:

<dd>ist der offizielle Go-Compiler und wurde initial von Ken Thompson in C geschrieben, basierte auf der „<a href="Plan_9_(Betriebssystem)" title="Plan 9 (Betriebssystem)">Plan 9</a>“-<a href="Toolchain" title="Toolchain">Toolchain</a> und nutzte <a href="Yacc" title="Yacc">Yacc</a>/<a href="GNU_Bison" title="GNU Bison">Bison</a> zum <a href="Parser" title="Parser">Parsen</a>. Mit Version 1.5 wurde dieser Compiler von C nach Go übersetzt und ist damit self-hosting. Ursprünglich bestand der Compiler aus mehreren ausführbaren Kommandos, die unterschiedliche Namen je nach Ziel-Architektur hatten: „8 g“ für <a href="X86-Architektur" title="X86-Architektur">x86</a>, „6 g“ für <a href="AMD64" title="AMD64">x86_64</a>, „5 g“ für <a href="ARM-Architektur" title="ARM-Architektur">ARM</a>. Mit Version 1.5 wurden sie zu einem einzelnen ausführbaren Kommando zusammengefasst (go tool compile), und die Ziel-Architektur kann über die Umgebungsvariable GOARCH gewählt werden.</dd>

<dt>Gccgo</dt>

<dd>von Ian Taylor ist ein Go-<a href="Front-End_und_Back-End" class="mw-redirect" title="Front-End und Back-End">Frontend</a> für die <a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GNU Compiler Collection</a> (GCC). Das in <a href="C%2B%2B" title="C++">C++</a> geschriebene Frontend nutzt zum Parsen einen <a href="Rekursiver_Abstieg" title="Rekursiver Abstieg">rekursiven Abstieg</a>. Die folgenden Backend-Schritte sind die der Standard-GCC-Verarbeitung.<a href="#cite_note-15">[15]</a> Durch dieses Vorgehen wird zwar die <a href="Kompilierzeit" class="mw-redirect" title="Kompilierzeit">Kompilierzeit</a> im Vergleich zum Gc-Compiler erhöht, jedoch ist der produzierte Code effizienter. Die GNU Compiler Collection (GCC) unterstützt Go 1 mit Version 4.7.1 vollständig,<a href="#cite_note-16">[16]</a> der <a href="GNU_Debugger" title="GNU Debugger">GNU Debugger</a> (gdb) unterstützt Go ab Version 7.5.<a href="#cite_note-17">[17]</a></dd></dl>

Beide Compiler implementieren eine parallele <a href="Automatische_Speicherbereinigung#Mark-and-Sweep-Algorithmus" class="mw-redirect" title="Automatische Speicherbereinigung">Mark-and-Sweep-Speicherbereinigung</a>.

Der offizielle Compiler wird von dem <a href="Kommandozeile" title="Kommandozeile">Kommandozeilen</a>-Werkzeug go begleitet, das als <a href="Fassade_(Entwurfsmuster)" title="Fassade (Entwurfsmuster)">Fassade</a> für verschiedene Werkzeuge dient, wie z. B. dem Installieren von Paketen aus Quelltext-<a href="Repository" title="Repository">Repositories</a> im Internet wie etwa <a href="GitHub" title="GitHub">GitHub</a> oder <a href="Google_Code" class="mw-redirect" title="Google Code">Google Code</a> (go get), dem automatischen Formatieren von Quelltext (go fmt), dem Ausführen von <a href="Modultest" title="Modultest">Tests</a> (go test), dem Erzeugen von Dokumentation aus Quelltext-Kommentaren (go doc) oder dem Kompilieren des Projektes (go build), sodass keinerlei <a href="Make" title="Make">Makefiles</a> nötig sind, wenn eine empfohlene Verzeichnisstruktur eingehalten wird.

<div class="mw-heading mw-heading2"><h2 id="Geschichte">Geschichte</h2></div>

Die Entwurfsphase begann am 21. September 2007, anfangs als 20-Prozent-Projekt auf Initiative von Robert Griesemer, Rob Pike und Ken Thompson. Bald darauf stießen weitere Entwickler dazu, und Go wurde zum Vollzeit-Projekt.<a href="#cite_note-18">[18]</a> Am 30. Oktober 2009 wurde Go von Rob Pike in einem Google TechTalk präsentiert und die Veröffentlichung als <a href="Freie_Software" title="Freie Software">freie Software</a> angekündigt, die dann wie angekündigt am 10. November erfolgte.<a href="#cite_note-19">[19]</a><a href="#cite_note-20">[20]</a> Seitdem sind zahlreiche Beiträge von Entwicklern aus der Go-Community außerhalb Googles hinzugekommen. Am 28. März 2012 wurde Version 1 freigegeben.<a href="#cite_note-21">[21]</a> Seitdem gelten Sprachspezifikation und Standardbibliothek als stabil und sollen innerhalb der 1.x-Serie auf Quelltext-Ebene abwärtskompatibel bleiben.<a href="#cite_note-22">[22]</a> Am 14. Mai 2013 wurde Go 1.1 freigegeben, das vor allem <a href="Rechenleistung" title="Rechenleistung">Performance</a>-Verbesserungen an der Implementierung enthält.<a href="#cite_note-23">[23]</a> Jeweils sechs Monate später erschienen die Versionen Go 1.2 bis Go 1.10.

Vom 24. bis zum 26. April 2014 fand die erste Konferenz zu Go, die GopherCon,<a href="#cite_note-24">[24]</a> in <a href="Denver" title="Denver">Denver</a> statt, die seitdem jährlich stattfindet.

<div class="mw-heading mw-heading2"><h2 id="Maskottchen">Maskottchen</h2></div>

Das Go-<a href="Maskottchen" title="Maskottchen">Maskottchen</a> ist eine <a href="Taschenratte" class="mw-redirect" title="Taschenratte">Taschenratte</a> (englisch Gopher). Es wurde von Renée French entworfen, die auch Glenda, das <a href="Plan_9_(Betriebssystem)" title="Plan 9 (Betriebssystem)">Plan-9</a>-Häschen, entworfen hat. Das <a href="Logo_(Zeichen)" title="Logo (Zeichen)">Logo</a> und das Maskottchen stehen unter der „<a href="Creative_Commons" title="Creative Commons">Creative Commons</a> Attribution 3.0“-Lizenz.

<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>

<ul><li>Alan A. A. Donovan, <a href="Brian_W._Kernighan" title="Brian W. Kernighan">Brian W. Kernighan</a>: <cite style="font-style:italic">The Go Programming Language</cite>. Pearson Education, 2015, ISBN 978-0-13-419044-0.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Go+%28Programmiersprache%29&rft.au=Alan+A.+A.+Donovan%2C+Brian+W.+Kernighan&rft.btitle=The+Go+Programming+Language&rft.date=2015&rft.genre=book&rft.isbn=9780134190440&rft.pub=Pearson+Education" style="display:none"> </li>

<li>Frank Müller: <cite style="font-style:italic">Systemprogrammierung in Google Go: Grundlagen, Skalierbarkeit, Performanz, Sicherheit</cite>. dpunkt.verlag, Heidelberg 2011, ISBN 978-3-89864-712-0.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Go+%28Programmiersprache%29&rft.au=Frank+M%C3%BCller&rft.btitle=Systemprogrammierung+in+Google+Go%3A+Grundlagen%2C+Skalierbarkeit%2C+Performanz%2C+Sicherheit&rft.date=2011&rft.genre=book&rft.isbn=9783898647120&rft.place=Heidelberg&rft.pub=dpunkt.verlag" style="display:none"> </li>

<li>Rainer Feike: <cite style="font-style:italic">Programmierung in Google Go: Neuigkeiten von Google in der Systemprogrammierung</cite>. Addison-Wesley, München/Boston 2010, ISBN 978-3-8273-3009-3.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Go+%28Programmiersprache%29&rft.au=Rainer+Feike&rft.btitle=Programmierung+in+Google+Go%3A+Neuigkeiten+von+Google+in+der+Systemprogrammierung&rft.date=2010&rft.genre=book&rft.isbn=9783827330093&rft.place=M%C3%BCnchen%2FBoston&rft.pub=Addison-Wesley" style="display:none"> </li>

<li>Caleb Doxsey: <cite class="lang" lang="en" dir="auto" style="font-style:italic">An Introduction to Programming in Go</cite>. 2012, ISBN 978-1-4783-5582-3 (englisch, <a rel="nofollow" class="external text" href="https://www.golang-book.com/">golang-book.com</a>).<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Go+%28Programmiersprache%29&rft.au=Caleb+Doxsey&rft.btitle=An+Introduction+to+Programming+in+Go&rft.date=2012&rft.genre=book&rft.isbn=9781478355823" style="display:none"> </li>

<li>Andreas Schröpfer: <cite style="font-style:italic">Go – Das Praxisbuch</cite>. dpunkt.verlag, 2020, ISBN 978-3-86490-713-5.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Go+%28Programmiersprache%29&rft.au=Andreas+Schr%C3%B6pfer&rft.btitle=Go+-+Das+Praxisbuch&rft.date=2020&rft.genre=book&rft.isbn=9783864907135&rft.pub=dpunkt.verlag" style="display:none"> </li>

<li>Kristian Köhler: <cite style="font-style:italic">Microservices mit Go</cite>. Rheinwerk Verlag, 2020, ISBN 978-3-8362-7559-0.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Go+%28Programmiersprache%29&rft.au=Kristian+K%C3%B6hler&rft.btitle=Microservices+mit+Go&rft.date=2020&rft.genre=book&rft.isbn=9783836275590&rft.pub=Rheinwerk+Verlag" style="display:none"> </li></ul>

<div class="mw-heading mw-heading2"><h2 id="Weblinks">Weblinks</h2></div>

<ul><li><a rel="nofollow" class="external text" href="https://go.dev/">Offizielle Website</a> (englisch)

<ul><li><a rel="nofollow" class="external text" href="https://go.dev/ref/spec">Spezifikation</a> (englisch)</li>

<li><a rel="nofollow" class="external text" href="https://go.dev/tour/">Eine interaktive Einführungs-Tour</a> (englisch)</li></ul></li>

<li>Übersetzungen (deutsch)

<ul><li><a rel="nofollow" class="external text" href="https://www.bitloeffel.de/DOC/golang/go_spec_de.html">Sprachbeschreibung usw.</a></li></ul></li>

<li><a rel="nofollow" class="external text" href="https://go.dev/talks/2012/splash.article">Go at Google: Language Design in the Service of Software Engineering</a> – Artikel von Rob Pike über das Sprachdesign (englisch)</li>

<li><a rel="nofollow" class="external text" href="https://www.youtube.com/watch?v=rKnDgT73v8s">Vortrag von Rob Pike</a> vom 30. Oktober 2009 (<a rel="nofollow" class="external text" href="https://go.dev/talks/2009/go_talk-20091030.pdf">Präsentationsfolien</a> (PDF; 242 kB))</li>

<li><a rel="nofollow" class="external text" href="https://gobyexample.com/">Go by example</a> (englisch)</li>

<li><a rel="nofollow" class="external text" href="https://opensource.archium.org/index.php/Der_Golang-Spicker#Ein_Go-Spickzettel_.28.22Cheat_Sheet.22.29">Der Golang-Spicker</a> – kompakte Übersicht (deutsch)</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>

<li id="cite_note-_9774563ad02d3acd-1"><a href="#cite_ref-_9774563ad02d3acd_1-0">↑</a> <a rel="nofollow" class="external text" href="https://github.com/golang/go/releases/tag/go1.25.5"><cite style="font-style:italic">Release 1.25.5</cite>.</a> 2. Dezember 2025 (abgerufen am 2. Dezember 2025).

</li>

<li id="cite_note-2"><a href="#cite_ref-2">↑</a> <a rel="nofollow" class="external text" href="http://www.techcrunch.com/2009/11/10/google-go-language/">Google-go-language</a>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">↑</a> <a rel="nofollow" class="external text" href="https://www.youtube.com/watch?v=FTl0tl9BGdc">Why Learn Go?</a> – Kurzinterview mit Rob Pike (Video, englisch)

</li>

<li id="cite_note-4"><a href="#cite_ref-4">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/talks/2012/splash.article">Go at Google: Language Design in the Service of Software Engineering</a>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/faq#no_pointer_arithmetic">go.dev - FAQ-Eintrag zu Zeigerarithmetik</a>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">↑</a> <a rel="nofollow" class="external text" href="https://www.youtube.com/watch?v=3DtUzH3zoFo">Origins of Go’s Concurrency Model</a>

</li>

<li id="cite_note-7"><a href="#cite_ref-7">↑</a> Jens Ihlenfeld: <a rel="nofollow" class="external text" href="https://www.golem.de/0911/71113.html">Go - schnelle Programmiersprache von Google.</a> In: <a href="Golem.de" class="mw-redirect" title="Golem.de">Golem.de</a>. 11. November 2009, abgerufen am 18. März 2025.<span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AGo+%28Programmiersprache%29&rft.title=Go+-+schnelle+Programmiersprache+von+Google&rft.description=Go+-+schnelle+Programmiersprache+von+Google&rft.identifier=https%3A%2F%2Fwww.golem.de%2F0911%2F71113.html&rft.creator=Jens+Ihlenfeld&rft.date=2009-11-11">

</li>

<li id="cite_note-8"><a href="#cite_ref-8">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/faq#generics">go.dev - FAQ-Eintrag zu Generics.</a> Abgerufen am 17. März 2022.<span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AGo+%28Programmiersprache%29&rft.title=go.dev+-+FAQ-Eintrag+zu+Generics&rft.description=go.dev+-+FAQ-Eintrag+zu+Generics&rft.identifier=https%3A%2F%2Fgo.dev%2Fdoc%2Ffaq%23generics">

</li>

<li id="cite_note-9"><a href="#cite_ref-9">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/faq#unicode_identifiers">go.dev - FAQ-Eintrag zu Unicode-Bezeichnern</a>

</li>

<li id="cite_note-10"><a href="#cite_ref-10">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/blog/declaration-syntax">go.dev Blogeintrag zu Syntax für Deklarationen</a>

</li>

<li id="cite_note-11"><a href="#cite_ref-11">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/play/p/GNj0Luvm2FU">Berechnung von Pi auf dem Go-Playground</a> (Beispiel zur nichtsequentiellen Berechnung von Pi)

</li>

<li id="cite_note-12"><a href="#cite_ref-12">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/tour/moretypes/1">A Tour Of Go - Pointers</a>

</li>

<li id="cite_note-13"><a href="#cite_ref-13">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/effective_go#channels">go.dev - Effective Go - Channels</a>

</li>

<li id="cite_note-14"><a href="#cite_ref-14">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/effective_go#chan_of_chan">go.dev - Effective Go - Channels of channels</a>

</li>

<li id="cite_note-15"><a href="#cite_ref-15">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/faq#Implementation">go.dev - Häufig gestellte Fragen zur Implementierung</a>

</li>

<li id="cite_note-16"><a href="#cite_ref-16">↑</a> <a rel="nofollow" class="external text" href="https://gcc.gnu.org/gcc-4.7/changes.html">GCC 4.7 Release Series Changes, New Features, and Fixes</a>

</li>

<li id="cite_note-17"><a href="#cite_ref-17">↑</a> <a rel="nofollow" class="external text" href="https://sourceware.org/legacy-ml/gdb-announce/2012/msg00004.html">GDB 7.5 Release Notes</a>

</li>

<li id="cite_note-18"><a href="#cite_ref-18">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/faq">Informationen zur Geschichte in offizieller FAQ</a>

</li>

<li id="cite_note-19"><a href="#cite_ref-19">↑</a> <a rel="nofollow" class="external text" href="https://opensource.googleblog.com/2009/11/hey-ho-lets-go.html">ursprüngliche Nachricht über die Veröffentlichung im Google Open Source Blog</a>

</li>

<li id="cite_note-20"><a href="#cite_ref-20">↑</a> <a rel="nofollow" class="external text" href="https://www.heise.de/ix/meldung/Go-Googles-Programmiersprache-fuer-Abenteuerlustige-855912.html">iX-Artikel vom 11. November 2009</a>

</li>

<li id="cite_note-21"><a href="#cite_ref-21">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/blog/go1">go.dev - Go version 1 is released</a>

</li>

<li id="cite_note-22"><a href="#cite_ref-22">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/doc/go1compat">go.dev - Go 1 and the Future of Go Programs</a>

</li>

<li id="cite_note-23"><a href="#cite_ref-23">↑</a> <a rel="nofollow" class="external text" href="https://go.dev/blog/go1.1">go.dev - Go 1.1 is released</a>

</li>

<li id="cite_note-24"><a href="#cite_ref-24">↑</a> <a rel="nofollow" class="external text" href="https://www.gophercon.com/">GopherCon</a>

</li>

</ol></div>

/* start https://de.wikipedia.org/ */

.mw-parser-output div.klappleiste{border:1px solid var(--dewiki-rahmenfarbe1);clear:both;font-size:95%;box-sizing:border-box;margin-top:1.5em;padding:2px}.mw-parser-output div.klappleiste:after{clear:both;content:"";display:block}.mw-parser-output div.klappleiste-bild{float:left;padding:2px}.mw-parser-output div.klappleiste-kopf{background:var(--dewiki-hintergrundfarbe5);color:var(--color-base,#202122);text-align:center;font-weight:bold}.mw-parser-output div.klappleiste.mw-collapsed .klappleiste-bild{display:none}.mw-parser-output div.klappleiste+div.klappleiste,.mw-parser-output div.klappleiste+link+div.klappleiste,.mw-parser-output div.klappleiste+link+link+div.klappleiste,.mw-parser-output div.klappleiste+link+style+div.klappleiste,.mw-parser-output div.klappleiste+style+div.klappleiste,.mw-parser-output div.klappleiste+style+style+div.klappleiste,.mw-parser-output div.klappleiste+style+link+div.klappleiste{margin-top:-1px}@media screen{html.skin-theme-clientpref-night .mw-parser-output .klappleiste-bild span[typeof="mw:File"]:not(.skin-invert-image) img{background-color:#c8ccd1}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .klappleiste-bild span[typeof="mw:File"]:not(.skin-invert-image) img{background-color:#c8ccd1}}

/* end https://de.wikipedia.org/ */

</style>

<div class="klappleiste-kopf">Programmiersprachen von <a href="Google_LLC" title="Google LLC">Google</a></div>

<a class="mw-selflink selflink">Go</a> |

<a href="Dart_(Programmiersprache)" title="Dart (Programmiersprache)">Dart</a> |

<a href="Carbon_(Programmiersprache)" title="Carbon (Programmiersprache)">Carbon</a>

</div>

</div></div>

<div>

Normdaten (Sachbegriff): <a href="Gemeinsame_Normdatei" title="Gemeinsame Normdatei">GND</a>: <a rel="nofollow" class="external text" href="https://d-nb.info/gnd/7725033-3">7725033-3</a> | <a href="Library_of_Congress_Control_Number" title="Library of Congress Control Number">LCCN</a>: <a rel="nofollow" class="external text" href="https://id.loc.gov/authorities/sh2012000746">sh2012000746</a> </div>

</div></div></div><div><div class="zim-footer">

Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-12-31" href="https://de.wikipedia.org/wiki/?title=Go_(Programmiersprache)&oldid=262899925">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.

</div>

</div></div>

</div>

</main>

</div>

</body></html>